home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / SciAn / src / ScianMain.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  13KB  |  698 lines
  1. /*ScianMain.c
  2.   Eric Pepke
  3.   Main routines for SciAn
  4. */
  5.  
  6. #include "Scian.h"
  7. #include "ScianTypes.h"
  8. #include "ScianArrays.h"
  9. #include "ScianLists.h"
  10. #include "ScianEvents.h"
  11. #include "ScianWindows.h"
  12. #include "ScianObjWindows.h"
  13. #include "ScianObjFunctions.h"
  14. #include "ScianGlobalFunctions.h"
  15. #include "ScianWindowFunctions.h"
  16. #include "ScianCurrentFunctions.h"
  17. #include "ScianVisWindows.h"
  18. #include "ScianDialogs.h"
  19. #include "ScianDatasets.h"
  20. #include "ScianColors.h"
  21. #include "ScianControls.h"
  22. #include "ScianDrawings.h"
  23. #include "ScianIcons.h"
  24. #include "ScianRecorders.h"
  25. #include "ScianFiles.h"
  26. #include "ScianFileSystem.h"
  27. #include "ScianGarbageMan.h"
  28. #include "ScianScripts.h"
  29. #include "ScianTimers.h"
  30. #include "ScianErrors.h"
  31. #include "ScianIDs.h"
  32. #include "ScianSpaces.h"
  33. #include "ScianPreferences.h"
  34. #include "ScianSciences.h"
  35. #include "ScianSnap.h"
  36. #include "ScianAxes.h"
  37. #include "ScianTextFiles.h"
  38. #include "ScianMenus.h"
  39.  
  40. Bool stuffInited = false;
  41. Bool runningRemote = false;
  42. real missingData = 1.1E37;
  43. real plusInf = 1E37;
  44. real minusInf = -1E37;
  45. Bool demoP = false;
  46. Bool scriptSelectP = false;
  47. Bool abortScriptP = true;
  48.  
  49. extern Bool runningScript;    /*True iff running script*/
  50.  
  51. #ifdef GRAPHICS
  52. #ifdef CURSORS4D
  53. /*Cursors*/
  54. Cursor watchCursor = 
  55.     {
  56.     0x07e0,
  57.     0x07e0,
  58.     0x07e0,
  59.     0x07e0,
  60.     0x0810,
  61.     0x1008,
  62.     0x1008,
  63.     0x11cc,
  64.     0x110c,
  65.     0x1108,
  66.     0x1108,
  67.     0x0810,
  68.     0x07e0,
  69.     0x07e0,
  70.     0x07e0,
  71.     0x07e0
  72.     };
  73. Cursor questionCursor = 
  74.     {
  75.     0x0300,
  76.     0x0300,
  77.     0x0000,
  78.     0x0300,
  79.     0x0300,
  80.     0x0300,
  81.     0x0380,
  82.     0x0180,
  83.     0x0070,
  84.     0x0038,
  85.     0x0018,
  86.     0x1818,
  87.     0x1818,
  88.     0x1c38,
  89.     0x0ff0,
  90.     0x07e0
  91.     };
  92. Cursor iconCursor = 
  93.     {
  94.     0xFFFF,
  95.     0xFFFF,
  96.     0xFFFF,
  97.     0xFFFF,
  98.     0xFFFF,
  99.     0xFFFF,
  100.     0xFFFF,
  101.     0xFFFF,
  102.     0xFFFF,
  103.     0xFFFF,
  104.     0xFFFF,
  105.     0xFFFF,
  106.     0xFFFF,
  107.     0xFFFF,
  108.     0xFFFF,
  109.     0xFFFF
  110.     };
  111. #endif
  112. #endif
  113.  
  114.  
  115. #ifdef PARANOID
  116. /*Define tracking memory allocations*/
  117.  
  118. #define NMEMCHUNKS    257
  119.  
  120. static long memStats[NMEMCHUNKS][2];
  121. #ifdef CACHEMEMORY
  122. static void *memCache[NMEMCHUNKS];
  123. #endif
  124.  
  125. void *Alloc(long n)
  126. /*Allocates n bytes*/
  127. {
  128.     register void *p;
  129.     if (n < NMEMCHUNKS)
  130.     {
  131.     ++memStats[n][0];
  132. #ifdef CACHEMEMORY
  133.     if (memCache[n])
  134.     {
  135.         p = memCache[n];
  136.         memCache[n] = *((void **) p);
  137.         *((long *) p) = n;
  138.         return (void *) (((long *) p) + 1);
  139.     }
  140. #endif
  141.     }
  142.     else
  143.     {
  144.     ++memStats[NMEMCHUNKS - 1][0];
  145.     }
  146.     p = malloc(n + sizeof(long));
  147.     *((long *) p) = n;
  148.     return (void *) (((long *) p) + 1);
  149. }
  150.  
  151. void *Realloc(void *p, long n)
  152. /*Reallocates p to be n bytes*/
  153. {
  154.     p = (void *) (((long *) p) - 1);
  155.     if (*((long *) p) < NMEMCHUNKS)
  156.     {
  157.     ++memStats[*((long *) p)][1];
  158.     }
  159.     else
  160.     {
  161.     ++memStats[NMEMCHUNKS - 1][1];
  162.     }
  163.     if (n < NMEMCHUNKS)
  164.     {
  165.     ++memStats[n][0];
  166.     }
  167.     else
  168.     {
  169.     ++memStats[NMEMCHUNKS - 1][0];
  170.     }
  171.     p = realloc(p, n + sizeof(long));
  172.     *((long *) p) = n;
  173.     return (void *) (((long *) p) + 1);
  174. }
  175.  
  176. void Free(void *p)
  177. /*Frees p*/
  178. {
  179.     register int n;
  180.     p = (void *) (((long *) p) - 1);
  181.     n = *((long *) p);
  182.     if (n < NMEMCHUNKS)
  183.     {
  184.     ++memStats[n][1];
  185.  
  186. #ifdef CACHEMEMORY
  187.     *((void **) p) = memCache[n];
  188.     memCache[n] = p;
  189. #else
  190.     free(p);
  191. #endif
  192.     }
  193.     else
  194.     {
  195.     ++memStats[NMEMCHUNKS - 1][1];
  196.     free(p);
  197.     }
  198. }
  199.  
  200. void PrintMemStats(void)
  201. /*Prints memory stats*/
  202. {
  203.     int k;
  204.     struct mallinfo mi;
  205.  
  206.     printf("Size    Allocations  Deallocations     Current\n");
  207.     for (k = 0; k < NMEMCHUNKS; ++k)
  208.     {
  209.     printf("%4d%c   %11d    %11d    %11d\n",
  210.         k, k == NMEMCHUNKS - 1 ? '+' : ' ', memStats[k][0], memStats[k][1],  memStats[k][0] - memStats[k][1]);
  211.     }
  212.  
  213.     mi = mallinfo();
  214.     fprintf(stderr,"arena=%d, ordblks=%d, smblks=%d, hblkhd=%d, hblks=%d\n",
  215.             mi.arena, mi.ordblks, mi.smblks, mi.hblkhd, mi.hblks);
  216.     fprintf(stderr,"usmblks=%d, fsmblks=%d, uordblks=%d, fordblks=%d, keepcost=%d\n",
  217.         mi.usmblks, mi.fsmblks, mi.uordblks, mi.fordblks, mi.keepcost);
  218. }
  219. #endif
  220.  
  221. /*Read states*/
  222. #define RS_FILE        0    /*Read names as file names*/
  223. #define RS_FORMAT    1    /*Read names as formats*/
  224. #define RS_LOG        2    /*Read names as log files*/
  225. #define RS_SCRIPT    3    /*Read names as script files*/
  226. #define RS_DIRECTORY    4    /*Read names as directory files*/
  227.  
  228. void ParseArgs(argc, argv)
  229. int argc;
  230. char *argv[];
  231. /*Parses the arguments in argc and argv*/
  232. {
  233.     int k;
  234.     char format[256];        /*Current file format*/
  235.     ObjPtr corral;        /*Corral in the datasets window*/
  236.     char *a;
  237.     Bool scriptSet;
  238.     int readState = RS_FILE;
  239.  
  240.     scriptSet = false;
  241.  
  242.     strcpy(format, "");
  243.  
  244.     for (k = 1; k < argc; ++k)
  245.     {
  246.     /*Go through arguments, parsing them*/
  247.     if (readState != RS_FILE)
  248.     {
  249.         /*Read this argument as a whatever*/
  250.         switch(readState)
  251.         {
  252.         case RS_FORMAT:
  253.             strncpy(format, argv[k], 255);
  254.             format[255] = 0;
  255.             break;
  256.         case RS_SCRIPT:
  257.             if (scriptSet)
  258.             {
  259.             fprintf(stderr, "%s: Only one script can be given on the command line.\n", argv[0]);
  260.             exit(-1);
  261.             }
  262.             scriptSet = true;
  263.             BeginScript(argv[k]);
  264.             break;
  265.         case RS_LOG:
  266.             if (strcmp(argv[k], "-") == 0)
  267.             {
  268.             OpenLogFile((char *) 0);
  269.             }
  270.             else
  271.             {
  272.             OpenLogFile(argv[k]);
  273.             }
  274.             break;
  275.         case RS_DIRECTORY:
  276.             {
  277.             char t[MAXPATHLEN + 1];
  278.             if (chdir(argv[k]) == 0) /* check if valid directory */
  279.             {
  280.                 getwd(t);    /* get expanded name back */
  281.                 GetFileWindow(t);
  282.                 chdir(dirSave);    /* return to original directory */
  283.             }
  284.             else
  285.             {
  286.                 fprintf(stderr, "%s: '%s' is an invalid directory.\n", argv[0], argv[k]);
  287.                 exit(-1);
  288.             }
  289.             }
  290.             break;
  291.         }
  292.         readState = RS_FILE;
  293.     }
  294.     else if (argv[k][0] == '-')
  295.     {
  296.         /*It's a switch*/
  297.         readState = RS_FILE;
  298.         
  299.         for (a = &(argv[k][1]); *a; ++a)
  300.         {
  301.         switch (*a)
  302.         {
  303.         case 'f':
  304.             /*New file format*/
  305.             readState = RS_FORMAT;
  306.             break;
  307.         case '1':
  308.             /*One observer, clock, whatever*/
  309.             ++a;
  310.             switch (*a)
  311.             {
  312.             case 'c':
  313.             case 'C':
  314.                 oneClock = true;
  315.                 break;
  316.             case 'o':
  317.             case 'O':
  318.                 oneObserver = true;
  319.                 break;
  320.             case 'l':
  321.             case 'L':
  322.                 oneLights = true;
  323.                 break;
  324.             case 'r':
  325.             case 'R':
  326.                 oneRenderer = true;
  327.                 break;
  328.             case 'p':
  329.             case 'P':
  330.                 onePalette = true;
  331.                 break;
  332.             default:
  333.                 fprintf(stderr, "%s: Unrecognized object type for -1 flag\n", argv[0]);
  334.                 exit(-1);
  335.             }
  336.             break;
  337.         case 's':
  338.             /*Script to run*/
  339.             readState = RS_SCRIPT;
  340.             break;
  341.         case 'S':
  342.             /*Select in scripts*/
  343.             scriptSelectP = true;
  344.             break;
  345.         case 'C':
  346.             /*Continue in scripts*/
  347.             abortScriptP = false;
  348.             break;
  349.         case 'l':
  350.             /*Open log file*/
  351.             readState = RS_LOG;
  352.             break;
  353.         case 'v':
  354.             /*Enable recording*/
  355. #ifdef GRAPHICS
  356. #ifdef IRIS
  357.             blankscreen(FALSE);
  358.             blanktime(0);
  359. #endif
  360. #endif
  361.             recordEnabled = true;
  362.             break;
  363.         case 'd':
  364.             /*Demo mode*/
  365.             demoP = true;
  366.             break;
  367.         case 'o':
  368.             /*Open a directory*/
  369.             readState = RS_DIRECTORY;
  370.             break;
  371.         default:
  372.             /*Undefined switch*/
  373.             fprintf(stderr, "%s: Switch %s is undefined.\n", argv[0], argv[k]);
  374.             exit(-1);
  375.         }
  376.         }
  377.     }
  378.     else if (argv[k][0] == '+')
  379.     {
  380.         if (0 == strcmp(argv[k], "+mdoc"))
  381.         {
  382.         EmitMenuDoc();
  383.         }
  384.     }
  385.     else
  386.     {
  387.         WinInfoPtr datasetsWindow;
  388.         /*It must be a file name*/
  389.  
  390.         datasetsWindow = DatasetsWindow();
  391.  
  392.         SelWindow(datasetsWindow);
  393.         IdleAllWindows();
  394.         LongOperation();
  395.         ReadFile(argv[k], format);
  396.     }
  397.     }
  398. }
  399.  
  400. Bool handlingSignals = true;
  401.  
  402. #ifdef SIGNALS
  403. #ifdef PROTO
  404. void SignalHandler(int sig, int code, struct sigcontext *context)
  405. #else
  406. void SignalHandler(sig, code, context)
  407. int sig;
  408. int code;
  409. struct sigcontext *context;
  410. #endif
  411. /*Handles signals*/
  412. {
  413.     if (0 == handlingSignals)
  414.     {
  415.     /*Just expire*/
  416.     return;
  417.     }
  418.     switch(sig)
  419.     {
  420. #ifdef SIGALRM
  421.     case SIGALRM:
  422.         /*Get some new events*/
  423.         NewEvents();
  424.         {
  425.         struct itimerval value, ovalue;
  426.     
  427.         value . it_interval . tv_sec = 0;
  428.         value . it_interval . tv_usec = 0;
  429.         value . it_value . tv_sec = 0;
  430.         value . it_value . tv_usec = 100000L;
  431.         setitimer(ITIMER_REAL, &value, &ovalue);
  432.         }
  433.         signal(SIGALRM, SignalHandler);
  434.         break;
  435. #endif
  436. #ifdef SIGDANGER
  437.     case SIGDANGER:
  438.         signal(SIGDANGER, SignalHandler);
  439.         break;
  440. #endif
  441.     }
  442. }
  443. #endif
  444.  
  445. TestTextFile()
  446. {
  447.     TextFilePtr file;
  448.  
  449.     file = OpenTextFile("testo.txt", TF_READ + TF_CONTINUATION + TF_HASHCOMMENTS);
  450.     if (file)
  451.     {
  452.     char *curLine;
  453.     while (curLine = GetNextLine(file))
  454.     {
  455.         char *chickenWhere;
  456.         chickenWhere = strstr(curLine, "chicken");
  457.         if (chickenWhere)
  458.         {
  459.         CurLineError(file, "'chicken' may not appear", chickenWhere,
  460.             chickenWhere + strlen("chicken"));
  461.         }
  462.     }
  463.     CloseTextFile(file);
  464.     }
  465.     else
  466.     {
  467.     perror("testo.txt");
  468.     }
  469. }
  470.  
  471. main(argc, argv)
  472. int argc;
  473. char *argv[];
  474. {
  475.     int k;
  476. #ifdef MALLOCH
  477. #ifdef M_MXFAST
  478.     mallopt(M_MXFAST, 1024);
  479. #endif
  480. #endif
  481.  
  482. #ifdef PARANOID
  483.     for (k = 0; k < NMEMCHUNKS; ++k)
  484.     {
  485.     memStats[k][0] = 0;
  486.     memStats[k][1] = 0;
  487. #ifdef CACHEMEMORY
  488.     memCache[k] = NULL;
  489. #endif
  490.     }
  491. #endif
  492.  
  493. #ifdef GRAPHICS
  494. #ifdef IRIS
  495.     foreground();
  496. #endif
  497. #endif
  498.  
  499. #ifdef SIGNALS
  500.     /*Set up signals*/
  501. #ifdef SIGDANGER
  502.     signal(SIGDANGER, SignalHandler);
  503. #endif
  504. #endif
  505.  
  506. #ifndef GETGDESCAFTER
  507.     GetConfiguration();
  508. #endif
  509.     InitNames();
  510.     InitObjects();
  511.     InitTextFiles();
  512.     InitArrays();
  513.     InitLists();
  514.     InitControls();
  515.     InitDatabase();
  516.     InitSciences();
  517.     InitAxes();
  518.     MainWindow();
  519.     ParseArgs(argc, argv);
  520. #ifdef INTERACTIVE
  521.     QueueDevices();
  522. #endif
  523.     InitEvents();
  524.     InitSnapshots();
  525.     MainLoop();
  526.     KillSnapshots();
  527.     KillEvents();
  528. #ifdef INTERACTIVE
  529.     UnqueueDevices();
  530. #endif
  531.     CloseAllLogFiles();
  532. #ifdef GRAPHICS
  533. #ifdef IRIS
  534.     if (recordEnabled)
  535.     {
  536.     blanktime(100000);
  537.     }
  538. #endif
  539. #endif
  540.     handlingSignals = false;
  541.     DisposeAllWindows();
  542.     KillWindowFunctions();
  543.     KillRepobjFunctions();
  544.     KillGlobalFunctions();
  545.     KillRecorders();
  546.     KillPreferences();
  547.     KillColors();
  548.     KillDialogs();
  549.     KillObjFunctions();
  550.     KillCurrentFunctions();
  551.     KillMenus();
  552.     KillVisWindows();
  553.     KillObjWindows();
  554.     KillWindows();
  555.     KillPictures();
  556.     KillVisObjects();
  557.     KillTimers();
  558.     KillSpaces();
  559.     KillFilters();
  560.     KillDatasets();
  561.     KillGeometry();
  562.     KillAnimation();
  563.     KillDrawings();
  564.     KillIcons();
  565.     KillSockets();
  566.     KillDraw();
  567.     KillAxes();
  568.     KillSciences();
  569.     KillDatabase();
  570.     KillControls();
  571.     KillJohnFiles();
  572.     KillFiles();
  573.     TrashDay();
  574.     KillLists();
  575.     KillArrays();
  576.     KillTextFiles();
  577.     KillObjects();
  578.     KillNames();
  579.     exit(0);
  580. }
  581.  
  582. #ifdef PROTO
  583. static void DefineFunctionKeys(void)
  584. #else
  585. static void DefineFunctionKeys()
  586. #endif
  587. /*Defines a bunch of function keys*/
  588. {
  589. #ifndef RELEASE
  590.     DefineFunctionKey(FK_1, 0, GF_UNDO);
  591. #endif
  592.     DefineFunctionKey(FK_2, 0, CF_CUT);
  593.     DefineFunctionKey(FK_3, 0, CF_COPY);
  594.     DefineFunctionKey(FK_4, 0, CF_PASTE);
  595.     DefineFunctionKey(FK_5, 0, OF_SHOW_CONTROLS);
  596.     DefineFunctionKey(FK_6, 0, WF_HIDEPANEL);
  597.     DefineFunctionKey(FK_7, 0, OF_PUSHTOBOTTOM);
  598.     DefineFunctionKey(FK_8, 0, OF_BRINGTOTOP);
  599.     DefineFunctionKey(FK_9, 0, OF_PICK_UP);
  600. #ifdef IRISNTSC
  601.     DefineFunctionKey(FK_10, 0, GF_TOGGLENTSC);
  602.     DefineFunctionKey(FK_11, 0, GF_TOGGLESTEREO);
  603. #endif
  604.     DefineFunctionKey(FK_12, 0, GF_CONTEXTHELP);
  605.     DefineFunctionKey(FK_PRINT_SCREEN, 0, WF_SAVEWINDOW);
  606.     DefineFunctionKey(FK_PRINT_SCREEN, F_SHIFTDOWN, WF_SAVEFWINDOW);
  607.     DefineFunctionKey(FK_PRINT_SCREEN, F_OPTIONDOWN, WF_SAVESCREEN);
  608.     DefineFunctionKey('q', F_OPTIONDOWN, GF_QUIT);
  609. #ifndef RELEASE
  610.     DefineFunctionKey('s', F_OPTIONDOWN, GF_NEWSEQUENCE);
  611. #endif
  612. }
  613.  
  614. InitStuff()
  615. /*Initializes stuff.  Has to be called after one window has been opened.*/
  616. {
  617.     if (!stuffInited)
  618.     {
  619. #ifdef GRAPHICS
  620. #ifdef GL4D
  621. #ifdef IRIS
  622.     defaultMonitor = getmonitor();
  623. #else
  624. #ifdef HZ60
  625.     defaultMonitor = HZ60;
  626. #else
  627.     defaultMonitor = 1;
  628. #endif
  629. #endif
  630. #endif
  631. #endif
  632. #ifdef GETGDESCAFTER
  633.     GetConfiguration();
  634. #endif
  635.     InitDraw();
  636.     InitIcons();
  637.     InitSockets();
  638.     InitColors();
  639.     InitDrawings();
  640.     InitAnimation();
  641.     InitSpaces();
  642.     InitTimers();
  643.     InitGeometry();
  644.     InitDatasets();
  645.     InitFilters();
  646.     InitFiles();
  647.     InitJohnFiles();
  648.     InitPictures();
  649.     InitFonts();
  650.     InitWindows();
  651.     InitObjWindows();
  652.     InitMenus();
  653.     InitCurrentFunctions();
  654.     InitObjFunctions();
  655.     InitVisWindows();
  656.     InitVisObjects();
  657.     InitDialogs();
  658.     InitPreferences();
  659.     InitRecorders();
  660.     InitGlobalFunctions();
  661.     InitRepobjFunctions();
  662.     InitWindowFunctions();
  663.     DefineFunctionKeys();
  664.  
  665.     /*Set up cursors*/
  666. #ifdef GRAPHICS
  667. #ifdef CURSORS4D
  668. #ifdef GL4D
  669.     curstype(C16X1);
  670. #endif
  671.     defcursor(WATCHCURSOR, watchCursor);
  672.     curorigin(WATCHCURSOR, 8, 8);
  673.     defcursor(QUESTIONCURSOR, questionCursor);
  674.     curorigin(QUESTIONCURSOR, 8, 8);
  675.     defcursor(ICONCURSOR, iconCursor);
  676.     curorigin(ICONCURSOR, 8, 8);
  677. #endif
  678. #endif
  679.     stuffInited = true;
  680. #ifdef SIGNALS
  681. #ifdef SIGALRM
  682.     signal(SIGALRM, SignalHandler);
  683.     {
  684.         struct itimerval value, ovalue;
  685.     
  686.         value . it_interval . tv_sec = 0;
  687.         value . it_interval . tv_usec = 0;
  688.         value . it_value . tv_sec = 0;
  689.         value . it_value . tv_usec = 100000L;
  690.     
  691.         setitimer(ITIMER_REAL, &value, &ovalue);
  692.     }
  693. #endif
  694. #endif
  695.     }
  696. }
  697.  
  698.